<script>
    // 为什么不要重写AccesmblyLoadContext的 LoadFromStream 方法？

            /*
                 在AssemblyLoadContext 中，从内存流加载程序集并不需要重写 LoadFromStream 方法，

                 原因与ALC的设计机制有关。

                 下面详细解释其中逻辑：
            */

            /*
                一、LoadFromStream 是 "主动加载"方法，无需重写

                         LoadFromStream 是 AssemblyLoadContext 提供的 "实例方法"(不是抽象方法、不是虚方法，所以不能被重写)，

                         用于"主动加载" 指定流中的程序集(内存流、文件流) 。

                         它的作用是：

                             1、直接从你提供的stream中读取程序集数据并加载

                             2、加载过程由 CLR 内部处理，不需要开发者重写。



                        例如，你从内存流加载动态编译的程序集时，直接调用即可

                                var alc = new DynamicAssemblyLoadContext();
                                using var ms = new MemoryStream(assemblyBytes); // 内存流中的程序集数据
                                Assembly assembly = alc.LoadFromStream(ms); // 直接调用，无需重写
            */

            /*
                二、Load方法的作用：  处理 "被动加载"

                        需要明确的是 ： Load(AssemblyName assemblyName) 方法的作用，与你 "主动加载程序集的方式"无关。

                        它的核心职责是处理 "被动加载"：

                        当你通过 LoadFromStream (或 LoadFromAssemblyPath 等) 主动加载一个程序集后，如果该程序集依赖其他程序集  （例如引用了 System.Data 或自定义库）

                        CLR会自动调用当前 ALC的Loadf方法，传入依赖程序集的 AssemblyName,询问当前ALC ："这个你能处理吗？"

                            此时，Load方法的返回值决定了依赖的加载方式：

                                1、返回null ：  表示 "我处理不了，交给默认ALC处理" (推荐，系统库通常由默认ALC加载)。

                                2、返回具体 Assembly:  表示 "我来加载这个依赖" (适用于需要自定义加载的场景)。

                        ★、即使是从内存流中加载程序集，也需要重写 Load 方法来控制依赖的加载，否则可能导致依赖被错误加载 (例如重复加载或加载到错误的上下文)。
            */

            /*
                三、正确的做法：  无论何种加载方式，Load方法都应该被重写！！

                        无论你是从内存流、文件路径、文件流...还是其他来源加载程序集，Load方法的重写都是必须的 (除非有特殊场景)。

                        原因是：

                              主动加载的程序集几乎必然有依赖项 (至少会依赖 mscorlib等核心库)，而Load方法是控制这些依赖如何加载的 "唯一入口"

                                        例如：  即使从内存流加载动态程序集，也应该保留Load方法的重写：

                                                public class DynamicAssemblyLoadContext : AssemblyLoadContext
                                                {
                                                    public DynamicAssemblyLoadContext() : base(isCollectible: true) { }

                                                    // 处理被动依赖加载
                                                    protected override Assembly? Load(AssemblyName assemblyName)
                                                    {
                                                        // 策略1：所有依赖都交给默认ALC处理（推荐）
                                                        return null;

                                                        // 策略2：仅处理特定依赖（如需隔离自定义库）
                                                        // if (assemblyName.Name == "MyCustomDependency")
                                                        // {
                                                        //     return LoadFromStream(...); // 从内存流加载自定义依赖
                                                        // }
                                                        // return null;
                                                    }
                                                }

                                                // 使用时从内存流主动加载
                                                var alc = new DynamicAssemblyLoadContext();
                                                using var ms = new MemoryStream(dynamicAssemblyBytes);
                                                Assembly assembly = alc.LoadFromStream(ms); // 直接调用，无需重写
            */

            /*
                四、何时需要重写 LoadFromStream 方法？

                        LoadFromStream 是个实例方法 (非抽象方法、非虚方法)，不能被重写。
            */

            /*
                ★、总结

                        1、从内存流加载程序集：直接调用 LoadFromStream 即可，无需重写。

                        2、Load 方法：无论加载方式（文件 / 内存流），通常都需要重写，目的是控制程序集依赖的加载逻辑，确保隔离性和可卸载性。

                        3、LoadFromStream不能被重写！！！
            */
</script>